////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  camxifebhiststats14.h
/// @brief Bayer Histogram (BHist) stats v1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef CAMXIFEBHISTSTATS14_H
#define CAMXIFEBHISTSTATS14_H

#include "camxispstatsmodule.h"

CAMX_NAMESPACE_BEGIN

// Register range from the SWI/HPG
static const UINT32 BHistStats14RegionWidth     = 2;    ///< BHist stats region width
static const UINT32 BHistStats14RegionHeight    = 2;    ///< BHist stats region width

static const UINT32 BHistStats14MinHorizRegions = 1;   ///< Minimum BHist stats horizontal region
static const UINT32 BHistStats14MinVertRegions  = 0;   ///< Minimum BHist stats vertical region

static const UINT32 ChannelSelectY              = 0x0;  ///< Channel selecton for Y channel
static const UINT32 ChannelSelectR              = 0x1;  ///< Channel selecton for R channel
static const UINT32 ChannelSelectGr             = 0x2;  ///< Channel selecton for Gr channel
static const UINT32 ChannelSelectGb             = 0x3;  ///< Channel selecton for Gb channel
static const UINT32 ChannelSelectB              = 0x4;  ///< Channel selecton for B channel

static const UINT32 BHistStats14NonUniformBin   = 0;    ///< Bit to select Uniform bins
static const UINT32 BHistStats14UniformBin      = 1;    ///< Bit to select Non -uniform bins

static const UINT32 BHistBinsPerChannel         = 1024; ///< Number of bins per channel  26
static const UINT32 BHistStatsSingleBinSize     = 4;    ///< Bayer Histogram stats output bits (per bin)

CAMX_BEGIN_PACKED

/// @brief BHist Stats Configuration
struct IFEBHistRegionConfig
{
    IFE_IFE_0_VFE_STATS_BHIST_RGN_OFFSET_CFG    regionOffset;   ///< BHist stats region offset config
    IFE_IFE_0_VFE_STATS_BHIST_RGN_NUM_CFG       regionNumber;   ///< BHist stats region number config
} CAMX_PACKED;

CAMX_END_PACKED

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @brief BHist Stats14 Class Implementation
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class BHistStats14 final : public ISPStatsModule
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Create
    ///
    /// @brief  Create BHistStats14 Object
    ///
    /// @param  pCreateData Pointer to the BHistStats14 Creation
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static CamxResult Create(
        IFEStatsModuleCreateData* pCreateData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// PrepareStripingParameters
    ///
    /// @brief  Prepare striping parameters for striping lib
    ///
    /// @param  pInputData Pointer to the Inputdata
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult PrepareStripingParameters(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Execute
    ///
    /// @brief  Execute process capture request to configure module
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResultSuccess if successful.
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual CamxResult Execute(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetDMITable
    ///
    /// @brief  Retrieve the DMI LUT
    ///
    /// @param  ppDMITable Pointer to which the module should update different DMI tables
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual VOID GetDMITable(
        UINT32** ppDMITable);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ~BHistStats14
    ///
    /// @brief  Destructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~BHistStats14();

protected:

    /// @brief BHist region configuration
    struct BHistRegionConfig
    {
        UINT32  horizontalOffset;       ///< BHist stats horizontal offset
        UINT32  verticalOffset;         ///< BHist stats vertical offset regions
        UINT32  horizontalRegionNum;    ///< BHist stats num of horizontal regions
        UINT32  verticalRegionNum;      ///< BHist stats num of vertical regionns
    };

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// BHistStats14
    ///
    /// @brief  Constructor
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BHistStats14();

private:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ValidateDependenceParams
    ///
    /// @brief  Validate the stats region of interest configuration from stats module
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResult Indicates if the input is valid or invalid
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult ValidateDependenceParams(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// UpdateIFEInternalData
    ///
    /// @brief  Update BHist configuration to the Internal Data
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID UpdateIFEInternalData(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CheckDependenceChange
    ///
    /// @brief  Check to see if the Dependence Trigger Data Changed
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return BOOL
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    BOOL CheckDependenceChange(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// RunCalculation
    ///
    /// @brief  Calculate the Register Value
    ///
    /// @param  pInputData   Pointer to the ISP input data
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID RunCalculation(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// ConfigureRegisters
    ///
    /// @brief  Configure scaler registers
    ///
    /// @param  pInputData          Pointer to the ISP input data
    /// @param  pNewRegionConfig    Region configuration to be set
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID ConfigureRegisters(
        ISPInputData* pInputData,
        const BHistRegionConfig* pNewRegionConfig);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CalculateRegionConfiguration
    ///
    /// @brief  Adjust ROI from stats to requirement based on hardware
    ///
    /// @param  pNewRegionConfig    Region configuration to be set
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID CalculateRegionConfiguration(
        BHistRegionConfig* pNewRegionConfig);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// DumpRegConfig
    ///
    /// @brief  Print register configuration of BHist module for debug
    ///
    ///
    /// @return None
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    VOID DumpRegConfig();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// CreateCmdList
    ///
    /// @brief  Create the Command List
    ///
    /// @param  pInputData Pointer to the ISP input data
    ///
    /// @return CamxResult
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    CamxResult CreateCmdList(
        ISPInputData* pInputData);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// MapColorChannelsToReg
    ///
    /// @brief  Map input color channels to Hw spec
    ///
    /// @param  channel Input color channel to be mapped to Hw spec
    ///
    /// @return CamxResult Indicates if the input is valid or invalid
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 MapColorChannelsToReg(
        ColorChannel channel);

    BHistStats14(const BHistStats14&)            = delete;    ///< Disallow the copy constructor
    BHistStats14& operator=(const BHistStats14&) = delete;    ///< Disallow assignment operator

    IFEBHistRegionConfig   m_regCmd;               ///< BHist stats region and threshold config
    ISPBHistStatsConfig    m_BHistConfig;          ///< BHist configuration data from stats
    UINT32                 m_BHistStatsUniformity; ///< BHist stats uniformity
    UINT32                 m_regionMultipleFactor; ///< BHist region offset and dimension multiple factor
};

CAMX_NAMESPACE_END

#endif // CAMXIFEBHISTSTATS14_H
